// utils/request.js

// 配置项
const config = {
  baseURL: 'https://dzxyk.cdu.edu.cn', // 基础路径
  timeout: 10000, // 超时时间（毫秒）
  header: { 
    'Content-Type': 'application/json' 
  }
}

// 请求队列（用于取消请求）
const pendingRequests = new Map()

/**
 * 生成请求唯一标识
 */
const generateReqKey = (config) => {
  const { method, url, params, data } = config
  return [method, url, JSON.stringify(params), JSON.stringify(data)].join('&')
}

/**
 * 添加请求到队列
 */
const addPendingRequest = (config) => {
  const requestKey = generateReqKey(config)
  config.cancelToken = config.cancelToken || new AbortController()
  pendingRequests.set(requestKey, config.cancelToken)
}

/**
 * 移除请求
 */
const removePendingRequest = (config) => {
  const requestKey = generateReqKey(config)
  if (pendingRequests.has(requestKey)) {
    pendingRequests.delete(requestKey)
  }
}

/**
 * 请求拦截器
 */
const requestInterceptor = (options) => {
  // 添加自定义 header（如 token）
  // const token = uni.getStorageSync('token')
  // if (token) {
  //   options.header = {
  //     ...options.header,
  //     Authorization: `Bearer ${token}`
  //   }
  // }
  
  // 添加到请求队列
  addPendingRequest(options)
  
  return options
}

/**
 * 响应拦截器
 */
const responseInterceptor = (response, options) => {
  // 从队列移除
  removePendingRequest(options)
  
  // 处理响应数据
  const { statusCode, data } = response
  if (statusCode >= 200 && statusCode < 300) {
    return data
  } else {
    return Promise.reject(response)
  }
}

/**
 * 错误处理
 */
const errorHandler = (error) => {
  // 取消请求特殊处理
  if (error.errMsg && error.errMsg.includes('abort')) {
    return Promise.reject({ message: '请求已取消' })
  }

  // 统一错误提示
  let errorMessage = '网络错误，请稍后重试'
  
  if (error.statusCode) {
    switch (error.statusCode) {
      case 401:
        errorMessage = '身份验证失败，请重新登录'
        // 跳转到登录页
        // uni.navigateTo({ url: '/pages/login/login' })
        break
      case 403:
        errorMessage = '没有权限访问'
        break
      case 404:
        errorMessage = '请求资源不存在'
        break
      case 500:
        errorMessage = '服务器内部错误'
        break
    }
  }
  
  // 显示错误提示（生产环境使用）
  if (process.env.NODE_ENV === 'production') {
    uni.showToast({
      title: errorMessage,
      icon: 'none',
      duration: 3000
    })
  }
  
  return Promise.reject(error)
}

/**
 * 封装请求方法
 */
const request = (options) => {
  // 合并配置
  const mergedOptions = {
    ...config,
    ...options,
    header: { ...config.header, ...(options.header || {}) }
  }
  
  // 执行请求拦截
  const processedOptions = requestInterceptor(mergedOptions)
  
  return new Promise((resolve, reject) => {
    // 发起请求
    uni.request({
      ...processedOptions,
      timeout: processedOptions.timeout,
      success: (response) => {
        try {
          const processedData = responseInterceptor(response, processedOptions)
          resolve(processedData)
        } catch (error) {
          reject(error)
        }
      },
      fail: (error) => {
        errorHandler(error).catch(reject)
      },
      complete: () => {
        removePendingRequest(processedOptions)
      }
    })
  })
}

// 挂载取消请求方法
request.cancel = (options) => {
  const requestKey = generateReqKey(options)
  if (pendingRequests.has(requestKey)) {
    const cancelToken = pendingRequests.get(requestKey)
    cancelToken.abort()
    pendingRequests.delete(requestKey)
  }
}

// 快捷方法
const methods = ['GET', 'POST', 'PUT', 'DELETE']
methods.forEach(method => {
  request[method.toLowerCase()] = (url, data, options = {}) => {
    return request({
      url,
      method,
      data,
      ...options
    })
  }
})

export default request